/*
 * Copyright (c) 2005, 2014 vacoor
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 */
package org.vacoor.nothing.common.util;

import java.util.HashMap;
import java.util.Map;

/**
 * 基本数据类型 - 包装器类型转换工具
 *
 * @author vacoor
 */
public abstract class Primitives {
    private static final Map<String, Class<?>> PRIMITIVE_TO_WRAPPER_TYPE = new HashMap<String, Class<?>>(9);
    private static final Map<Class<?>, Class<?>> WRAPPER_TO_PRIMITIVE_TYPE = new HashMap<Class<?>, Class<?>>(9);

    static {
        PRIMITIVE_TO_WRAPPER_TYPE.put(Boolean.TYPE.getName(), Boolean.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Character.TYPE.getName(), Character.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Byte.TYPE.getName(), Byte.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Short.TYPE.getName(), Short.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Integer.TYPE.getName(), Integer.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Long.TYPE.getName(), Long.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Float.TYPE.getName(), Float.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Double.TYPE.getName(), Double.class);
        PRIMITIVE_TO_WRAPPER_TYPE.put(Void.TYPE.getName(), Void.class);

        WRAPPER_TO_PRIMITIVE_TYPE.put(Boolean.class, Boolean.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Character.class, Character.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Byte.class, Byte.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Short.class, Short.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Integer.class, Integer.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Long.class, Long.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Float.class, Float.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Double.class, Double.TYPE);
        WRAPPER_TO_PRIMITIVE_TYPE.put(Void.class, Void.TYPE);
    }

    /**
     * 给定类型是否是基本数据类型的包装器类型
     *
     * @param type
     * @return
     */
    public static boolean isWrapperType(Class<?> type) {
        return WRAPPER_TO_PRIMITIVE_TYPE.containsKey(type);
    }

    /**
     * 获取给定基本数据类型名称对应的包装器类型
     *
     * @param primitive
     * @return
     */
    public static Class<?> wrap(String primitive) {
        return PRIMITIVE_TO_WRAPPER_TYPE.get(primitive);
    }

    /**
     * 获取给定基本数据类型对应的包装器类型
     * <p/>
     * 如果给定类型不是基本数据类型则返回给定参数
     */
    public static Class<?> wrap(Class<?> primitive) {
        Class<?> wrapped = wrap(primitive.getName());
        return wrapped != null ? wrapped : primitive;
    }

    /**
     * 返回给定数组中基本数据类型被包装器类型替换后的数组
     *
     * @param primitives
     * @return
     */
    public static Class<?>[] wrap(Class<?>[] primitives) {
        Class<?>[] wrapped = new Class<?>[primitives.length];

        for (int i = 0; i < primitives.length; i++) {
            wrapped[i] = wrap(primitives[i]);
        }
        return wrapped;
    }

    /**
     * 返回给定包装器类型对应的基本数据类型
     *
     * @param wrapper
     * @return
     */
    public static Class<?> unwrap(Class<?> wrapper) {
        Class<?> unwrapped = WRAPPER_TO_PRIMITIVE_TYPE.get(wrapper);
        return unwrapped != null ? unwrapped : wrapper;
    }

    /**
     * 返回给定数组中包装器类型被基本数据类型替换后的数组
     *
     * @param wrappers
     * @return
     */
    public static Class<?>[] unwrap(Class<?>[] wrappers) {
        Class<?>[] unwrapped = new Class<?>[wrappers.length];

        for (int i = 0; i < wrappers.length; i++) {
            unwrapped[i] = unwrap(wrappers[i]);
        }
        return unwrapped;
    }


    private Primitives() {
    }
}
